// **********************************************************************
//
// Copyright (c) 2003-2009 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************

// Ice version 3.3.1
// Generated from file `Imagefeaturedetector.ice'

#include <Imagefeaturedetector.h>
#include <Ice/LocalException.h>
#include <Ice/ObjectFactory.h>
#include <Ice/BasicStream.h>
#include <IceUtil/Iterator.h>
#include <IceUtil/ScopedArray.h>

#ifndef ICE_IGNORE_VERSION
#   if ICE_INT_VERSION / 100 != 303
#       error Ice version mismatch!
#   endif
#   if ICE_INT_VERSION % 100 > 50
#       error Beta header file detected
#   endif
#   if ICE_INT_VERSION % 100 < 1
#       error Ice patch level mismatch!
#   endif
#endif

::Ice::Object* IceInternal::upCast(::RoboCompImagefeaturedetector::Imagefeaturedetector* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RoboCompImagefeaturedetector::Imagefeaturedetector* p) { return p; }

void
RoboCompImagefeaturedetector::__read(::IceInternal::BasicStream* __is, ::RoboCompImagefeaturedetector::ImagefeaturedetectorPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::RoboCompImagefeaturedetector::Imagefeaturedetector;
        v->__copyFrom(proxy);
    }
}

const ::std::string&
IceProxy::RoboCompImagefeaturedetector::Imagefeaturedetector::ice_staticId()
{
    return ::RoboCompImagefeaturedetector::Imagefeaturedetector::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::RoboCompImagefeaturedetector::Imagefeaturedetector::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::RoboCompImagefeaturedetector::Imagefeaturedetector);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::RoboCompImagefeaturedetector::Imagefeaturedetector::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::RoboCompImagefeaturedetector::Imagefeaturedetector);
}

::IceProxy::Ice::Object*
IceProxy::RoboCompImagefeaturedetector::Imagefeaturedetector::__newInstance() const
{
    return new Imagefeaturedetector;
}

::Ice::ObjectPtr
RoboCompImagefeaturedetector::Imagefeaturedetector::ice_clone() const
{
    throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
    return 0; // to avoid a warning with some compilers
}

static const ::std::string __RoboCompImagefeaturedetector__Imagefeaturedetector_ids[2] =
{
    "::Ice::Object",
    "::RoboCompImagefeaturedetector::Imagefeaturedetector"
};

bool
RoboCompImagefeaturedetector::Imagefeaturedetector::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RoboCompImagefeaturedetector__Imagefeaturedetector_ids, __RoboCompImagefeaturedetector__Imagefeaturedetector_ids + 2, _s);
}

::std::vector< ::std::string>
RoboCompImagefeaturedetector::Imagefeaturedetector::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RoboCompImagefeaturedetector__Imagefeaturedetector_ids[0], &__RoboCompImagefeaturedetector__Imagefeaturedetector_ids[2]);
}

const ::std::string&
RoboCompImagefeaturedetector::Imagefeaturedetector::ice_id(const ::Ice::Current&) const
{
    return __RoboCompImagefeaturedetector__Imagefeaturedetector_ids[1];
}

const ::std::string&
RoboCompImagefeaturedetector::Imagefeaturedetector::ice_staticId()
{
    return __RoboCompImagefeaturedetector__Imagefeaturedetector_ids[1];
}

void
RoboCompImagefeaturedetector::Imagefeaturedetector::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__write(__os);
#else
    ::Ice::Object::__write(__os);
#endif
}

void
RoboCompImagefeaturedetector::Imagefeaturedetector::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__read(__is, true);
#else
    ::Ice::Object::__read(__is, true);
#endif
}

void
RoboCompImagefeaturedetector::Imagefeaturedetector::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RoboCompImagefeaturedetector::Imagefeaturedetector was not generated with stream support";
    throw ex;
}

void
RoboCompImagefeaturedetector::Imagefeaturedetector::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RoboCompImagefeaturedetector::Imagefeaturedetector was not generated with stream support";
    throw ex;
}

void 
RoboCompImagefeaturedetector::__patch__ImagefeaturedetectorPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RoboCompImagefeaturedetector::ImagefeaturedetectorPtr* p = static_cast< ::RoboCompImagefeaturedetector::ImagefeaturedetectorPtr*>(__addr);
    assert(p);
    *p = ::RoboCompImagefeaturedetector::ImagefeaturedetectorPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RoboCompImagefeaturedetector::Imagefeaturedetector::ice_staticId(), v->ice_id());
    }
}

bool
RoboCompImagefeaturedetector::operator==(const ::RoboCompImagefeaturedetector::Imagefeaturedetector& l, const ::RoboCompImagefeaturedetector::Imagefeaturedetector& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
RoboCompImagefeaturedetector::operator<(const ::RoboCompImagefeaturedetector::Imagefeaturedetector& l, const ::RoboCompImagefeaturedetector::Imagefeaturedetector& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}
